Definition

A bug is an error, flaw, failure, or fault in a computer program or system that produces unexpected or incorrect results. Bugs can occur due to mistakes made by programmers during the coding process, incorrect assumptions, miscommunications, or unexpected interactions between different parts of the software.

Types

• The Typing-bug: You did not type the things you wanted to type
• The Code-bug: Your code does not do the things you intended it to do, but it was typed correctly
• The Think-bug: Everything came out just as planned – but now that you see the result, you find that you planned the wrong thing

The Typing-bug is under control with the use of strongly typed languages that use static checking with compilers. The strange thing is that not every coder understands the brilliance of this. Many developers understand the brilliance but are forced to use interpreting languages since they are the only, or at least, the most common, tool that works in the target environment. Javascript is one example.

The Code-bugs are managed with unit tests which, in short, explain what you expect your active code to do with some more test code.

The Think-bug –  the only practical way to manage this kind of bug is to increase the development speed so that you can verify your thoughts quickly – learn, tweak, and move on, over and over. This is where model-driven development shines.

Clients and employers that pay for developers and coders should ensure that the only bugs the developers are engaged in are Think-bugs.

The Think-bug is the only kind of bug that gives value back to the domain issues we are set to solve. The other types of bugs result from crappy tools and sloppiness from an immature field of engineering.

Model-driven development, as delivered with ECO, raises the quality by being declarative in every aspect that involves your business objects – and thus nil out Typing-bugs and Code-bugs. It also increases the development speed so that the Think-bugs can be managed swiftly and elegantly.

In the '90s

Earlier, it was believed that the Think-bugs could be avoided by a very detailed analysis phase, such as the traditional water-fall methods like Rational-Unified-Process(RUP). Now, very few software engineers back these ideas. The Think-bugs often do not originate from a poor understanding of now but rather from an enlightenment of how it should be that grows slowly as a project progresses. This is why SCRUM and Agile strategies are much better at software development – they have room for dealing with ''Think-bugs''.

Using model-driven tools like ECO enables you to be truly agile. Not only are the tools at their best when we need to deal with the late changes that the Think-bugs often are, but developers tend to defend a solution they invested in (as all humans do). Having tools that minimize the investment done gives us developers who are open to change the ability to reason about the Think-bugs without being defensive – this is key to solving Think-bugs.